home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Games Collection 1 / software vault.zip / software vault / CDR10 / MAPEDIT.ZIP / PLOW.C < prev    next >
C/C++ Source or Header  |  1993-05-13  |  12KB  |  611 lines
  1. #include "paint.h"
  2. #include <string.h>
  3.  
  4. struct mypal_struct{
  5.     int r;
  6.     int g;
  7.     int b;
  8. }mypal[256];
  9.  
  10.  
  11. exit_prog()
  12. {
  13.     mousecursor(0);
  14.     vmode(3);
  15.     exit(0);
  16. }
  17.  
  18. show_screen()
  19. {
  20.     memcpy(scrptr,bufptr,64000);
  21.     cvis=0;
  22. }
  23.  
  24. block(int x,int y,unsigned char color)
  25. {
  26.     int loop,loop2;
  27.     for(loop=0;loop<8;loop++)
  28.     {
  29.         for(loop2=0;loop2<8;loop2++)
  30.         {
  31.             *(scrptr+((y*8)+loop)*320+(x*8)+loop2)=color;
  32.         }
  33.     }
  34. }
  35.  
  36.  
  37. waitup()
  38. {
  39.     while(mousebuttons())
  40.         ;;
  41. }
  42.  
  43.  
  44. bigchar(char *ctp)
  45. {
  46.     int loop,loop2;
  47.     for(loop=0;loop<8;loop++)
  48.     {
  49.         for(loop2=0;loop2<8;loop2++)
  50.         {
  51.             block(loop+1,loop2+1,*(ctp+loop+loop2*8));
  52.         }
  53.     }
  54. }
  55.  
  56. vmode(int videomode)
  57. {
  58.     union REGS reg;
  59.     reg.h.ah = 0;
  60.     reg.h.al = videomode;
  61.     int86 (0x10,®,®);
  62. }
  63.  
  64. load_charset()
  65. {
  66.     FILE *fptr;
  67.     if(!(fptr=fopen("charset.dat","rb")))
  68.     {
  69.         vmode(3);
  70.         printf("\nCould not open internal character set file charset.dat !");
  71.         exit(0);
  72.     }
  73.     fread(&csptr,1,16384,fptr);
  74.     fclose(fptr);
  75. }
  76.  
  77. load_map(char *mapname)
  78. {
  79.     FILE *fptr;
  80.     if(!(fptr=fopen(mapname,"rb")))
  81.     {
  82.         vmode(3);
  83.         printf("\nCould not open for reading file %s!",mapname);
  84.         exit(0);
  85.     }
  86.  
  87.     fread(mapptr,sizeof(char),64000,fptr);
  88.     fclose(fptr);
  89. }
  90.  
  91. save_map(char *mapname)
  92. {
  93.     FILE *fptr;
  94.     if(!(fptr=fopen(mapname,"wb+")))
  95.     {
  96.         vmode(3);
  97.         printf("\nCould not open for writing file %s !",mapname);
  98.         exit(0);
  99.     }
  100.  
  101.     fwrite(mapptr,sizeof(char),64000,fptr);
  102.     fclose(fptr);
  103. }
  104.  
  105.  
  106. save_attributes()
  107. {
  108.     FILE *fptr;
  109.  
  110.     if(!(fptr=fopen("chset.atr","wb+")))
  111.     {
  112.         vmode(3);
  113.         printf("\nCould not open attribute file chset.atr !");
  114.         exit(0);
  115.     }
  116.     fwrite(ca,sizeof(struct character_attribute_struct),1000,fptr);
  117.     fclose(fptr);
  118.     return;
  119. }
  120.  
  121. load_attributes()
  122. {
  123.     FILE *fptr;
  124.  
  125.     if(!(fptr=fopen("chset.atr","rb")))
  126.     {
  127.         vmode(3);
  128.         printf("\nCould not open attribute file chset.atr !");
  129.         exit(0);
  130.     }
  131.     fread(ca,sizeof(struct character_attribute_struct),1000,fptr);
  132.     fclose(fptr);
  133.     return;
  134. }
  135.  
  136. btc(int dx,int dy,char *dest)
  137. {
  138.     int loop,loop2;
  139.  
  140.     if(dx<0 || dx>39 || dy<0 || dy >24)
  141.     {
  142.         for(loop=0;loop<64;loop++)
  143.         {
  144.             dest[loop]=0;
  145.         }
  146.     }
  147.     else
  148.     {
  149.     for(loop=0;loop<8;loop++)
  150.     {
  151.         for(loop2=0;loop2<8;loop2++)
  152.         {
  153.             dest[loop*8+loop2]=*(bufptr+((dy*8)+loop)*320+(dx*8)+loop2);
  154.         }
  155.     }
  156.     }
  157. }
  158.  
  159. ctb(int x, int y,char *source)
  160. {
  161.     int loop,loop2;
  162.  
  163.     for(loop=0;loop<8;loop++)
  164.     {
  165.         for(loop2=0;loop2<8;loop2++)
  166.         {
  167.             *(bufptr+((y*8)+loop)*320+(x*8)+loop2)=source[loop*8+loop2];
  168.         }
  169.     }
  170. }
  171.  
  172. cts(int x,int y,char *source)
  173. {
  174.     register char loop;
  175.     register char loop2;
  176.  
  177.     for(loop=0;loop<8;loop++)
  178.     {
  179.         for(loop2=0;loop2<8;loop2++)
  180.         {
  181.             *(scrptr+((y*8)+loop)*320+(x*8)+loop2)=source[loop*8+loop2];
  182.         }
  183.     }
  184. }
  185.  
  186. pch(int px,int py,unsigned int outchar)
  187. {
  188.     register char loop;
  189.  
  190.     for(loop=0;loop<8;loop++)
  191.     {
  192.             memcpy(scrptr+(py*8+loop)*320+px*8,bufptr+(((outchar/40)*8)+loop)*320+((outchar%40)*8),8);
  193.     }
  194. }
  195.  
  196. load_db()
  197. {
  198.     FILE * fptr;
  199.     int loop;
  200.  
  201.     if(!(fptr=fopen("sprites.dat","rb")))
  202.     {
  203.         printf("\nCould not open Sprite Data file !");
  204.         exit(0);
  205.     }
  206.     fread(&db,sizeof(db),1,fptr);
  207.     fread(&si[0],sizeof(struct sprite_struct),100,fptr);
  208.     for(loop=0;loop<db.num_sprites;loop++)
  209.     {
  210.         if(!(si[loop].pict=(char far *) malloc(si[loop].width*si[loop].height)))
  211.         {
  212.             printf("\nError Allocating memory for sprite %d!",loop);
  213.             exit(0);
  214.         }
  215.         fread(si[loop].pict,si[loop].width*si[loop].height,1,fptr);
  216.     }
  217. }
  218.  
  219. putsprite(int xs, int ys, int xlen, int ylen, char *sprbuf)
  220. {
  221.     int loop;
  222.  
  223.     for(loop=0;loop<ylen;loop++)
  224.     {
  225.         memcpy(scrptr+(ys+loop)*320+xs,sprbuf+loop*xlen,xlen);
  226.     }
  227. }
  228.  
  229. show_sprite(int xs, int ys,char *sprname)
  230. {
  231.     int loop;
  232.     for(loop=0;loop<db.num_sprites;loop++)
  233.     {
  234.         if(strcmpi(si[loop].name,sprname)==0)
  235.         {
  236.             mousecursor(0);
  237.             putsprite(xs,ys,si[loop].width,si[loop].height,si[loop].pict);
  238.             mousecursor(1);
  239.             return;
  240.         }
  241.     }
  242. }
  243.  
  244. vwait()
  245. {
  246.     while((inp(0x3da)&8))
  247.         ;;
  248.     while(!(inp(0x3da)&8))
  249.         ;;
  250. }
  251.  
  252. line(int x1, int y1, int x2, int y2, int color,char xor)
  253. {
  254.     int dx, dy, dxabs, dyabs, px, py, sdx, sdy, x, y;
  255.     int i;
  256.  
  257.     dx = x2 - x1;
  258.     dy = y2 - y1;
  259.     sdx = sign(dx);
  260.     sdy = sign(dy);
  261.     dxabs = abs(dx);
  262.     dyabs = abs(dy);
  263.     x = 0;
  264.     y = 0;
  265.     px = x1;
  266.     py = y1;
  267.     if (dxabs >= dyabs)
  268.     {
  269.         for (i=0; i<dxabs; i++)
  270.         {
  271.             y += dyabs;
  272.             if (y>=dxabs)
  273.             {
  274.                 y -= dxabs;
  275.                 py += sdy;
  276.             }
  277.             px += sdx;
  278.             if(xor)
  279.                 xplot(px,py,color);
  280.             else
  281.                 plot(px,py,color);
  282.         }
  283.     }
  284.     else
  285.     {
  286.         for (i=0; i<dyabs; i++)
  287.         {
  288.             x += dxabs;
  289.             if (x>=dyabs)
  290.             {
  291.                 x -= dyabs;
  292.                 px += sdx;
  293.             }
  294.             py += sdy;
  295.             if(xor)
  296.                 xplot(px,py,color);
  297.             else
  298.                 plot(px,py,color);
  299.         }
  300.     }
  301. }
  302.  
  303. show_chset(int scrstart,int charstart)
  304. {
  305.     mousecursor(0);
  306.     memcpy(scrptr+scrstart*320,bufptr+charstart*8*320,320*(200-scrstart));
  307.     mousecursor(1);
  308. }
  309.  
  310.  
  311. ask_exit()
  312. {
  313.     int mousex;
  314.     int mousey;
  315.     show_sprite(0,tbar,"quitmessage");
  316.     for(;;)
  317.     {
  318.         mousex=mousecol();
  319.         mousey=mouserow();
  320.         if(mousey>=tbar && mousey<tbar+8)
  321.         {
  322.             if(mousebuttons())
  323.             {
  324.                 if(mousex>291 && mousex<307)
  325.                 {
  326.                     show_sprite(292,tbar,"yes");
  327.                     while(mousebuttons())
  328.                         ;;
  329.                     show_sprite(0,tbar,"mainmenubar");
  330.                     ask_save();
  331.                     show_sprite(0,tbar,"mainmenubar");
  332.                     exit_prog();
  333.                     return;
  334.                 }
  335.                 if(mousex>307)
  336.                 {
  337.                     show_sprite(308,tbar,"no");
  338.                     while(mousebuttons())
  339.                         ;;
  340.                     show_sprite(0,tbar,"mainmenubar");
  341.                     return;
  342.                 }
  343.             }
  344.         }
  345.     }
  346. }
  347.  
  348. ask_save()
  349. {
  350.     int mousex,mousey;
  351.     show_sprite(0,tbar,"savemessage");
  352.     for(;;)
  353.     {
  354.         mousex=mousecol();
  355.         mousey=mouserow();
  356.         if(mousey>=tbar && mousey<tbar+8)
  357.         {
  358.             if(mousebuttons())
  359.             {
  360.                 if(mousex>291 && mousex<307)
  361.                 {
  362.                     show_sprite(292,tbar,"yes");
  363.                     save_map(mapname);
  364.                     save_pcx(charsetname,bufptr);
  365.                     save_attributes();
  366.                     while(mousebuttons())
  367.                         ;;
  368.                     show_sprite(0,tbar,"mainmenubar");
  369.                     return;
  370.                 }
  371.                 if(mousex>307)
  372.                 {
  373.                     show_sprite(308,tbar,"no");
  374.                     while(mousebuttons())
  375.                         ;;
  376.                     show_sprite(0,tbar,"mainmenubar");
  377.                     return;
  378.                 }
  379.             }
  380.         }
  381.     }
  382. }
  383.  
  384. cross(int x, int y,int bottom,int top)
  385. {
  386.     line(x,top,x,bottom,0xa5,1);
  387.     line(0,y,319,y,0xa5,1);
  388. }
  389.  
  390. reverse (char *ctr)
  391. {
  392.     char buffer[64];
  393.     int loop,loop2;
  394.  
  395.     for(loop=0;loop<8;loop++)
  396.     {
  397.         memcpy(buffer,ctr+loop*8,8);
  398.         for(loop2=0;loop2<8;loop2++)
  399.         {
  400.             *(ctr+loop*8+7-loop2)=*(buffer+loop2);
  401.         }
  402.     }
  403. }
  404.  
  405. up (char *ctr)
  406. {
  407.     char temp[64];
  408.  
  409.     int loop,loop2;
  410.     memcpy(temp,ctr,8);
  411.  
  412.     for(loop=0;loop<7;loop++)
  413.     {
  414.         memcpy(ctr+loop*8,ctr+(loop+1)*8,8);
  415.     }
  416.     memcpy(ctr+7*8,temp,8);
  417. }
  418.  
  419. down(char *ctr)
  420. {
  421.     char temp[64];
  422.  
  423.     int loop,loop2;
  424.     memcpy(temp,ctr+7*8,8);
  425.  
  426.     for(loop=7;loop>0;loop--)
  427.     {
  428.         memcpy(ctr+(loop)*8,ctr+(loop-1)*8,8);
  429.     }
  430.     memcpy(ctr,temp,8);
  431. }
  432.  
  433. left(char *ctr)
  434. {
  435.     char temp;
  436.     int loop,loop2;
  437.  
  438.     for(loop=0;loop<8;loop++)
  439.     {
  440.         temp=*(ctr+loop*8);
  441.         for(loop2=0;loop2<7;loop2++)
  442.             *(ctr+loop*8+loop2)=*(ctr+loop*8+loop2+1);
  443.         *(ctr+loop*8+7)=temp;
  444.     }
  445. }
  446.  
  447. right(char *ctr)
  448. {
  449.     char temp;
  450.     int loop,loop2;
  451.  
  452.     for(loop=0;loop<8;loop++)
  453.     {
  454.         temp=*(ctr+loop*8+7);
  455.         for(loop2=7;loop2>0;loop2--)
  456.             *(ctr+loop*8+loop2)=*(ctr+loop*8+loop2-1);
  457.         *(ctr+loop*8)=temp;
  458.     }
  459. }
  460.  
  461. set_palette()
  462. {
  463.     register int loop;
  464.  
  465.     for(loop=0;loop<256;loop++)
  466.     {
  467.         outp(0x3c8,loop);
  468.         outp(0x3c9,pal[loop].red);
  469.         outp(0x3c9,pal[loop].green);
  470.         outp(0x3c9,pal[loop].blue);
  471.         mypal[loop].r=pal[loop].red;
  472.         mypal[loop].g=pal[loop].green;
  473.         mypal[loop].b=pal[loop].blue;
  474.     }
  475. }
  476.  
  477. makepal()
  478. {
  479.     int loop,loop2,loop3;
  480.     union REGS inregs,outregs;
  481.     int count;
  482.  
  483.     pal[0].red=0;
  484.     pal[0].green=0;
  485.     pal[0].blue=0;
  486.  
  487.     pal[1].red=255;
  488.     pal[1].green=255;
  489.     pal[1].blue=255;
  490.  
  491.     count=2;
  492.     for(loop=0;loop<32;loop++)
  493.     {
  494.         pal[count].red=loop*2;
  495.         pal[count].green=loop*2;
  496.         pal[count].blue=loop*2;
  497.         count++;
  498.     }
  499.  
  500.     for(loop=0;loop<6;loop++)
  501.     {
  502.         for(loop2=0;loop2<6;loop2++)
  503.         {
  504.             for(loop3=0;loop3<6;loop3++)
  505.             {
  506.                 pal[count].red=(loop*10);        /* red   */
  507.                 pal[count].green=(loop2*10);     /* green */
  508.                 pal[count].blue=(loop3*10);      /* blue  */
  509.                 count++;
  510.             }
  511.         }
  512.     }
  513. }
  514.  
  515. show_pal()
  516. {
  517.     int loop,loop2;
  518.  
  519.     block(0,18,0);
  520.     block(1,18,1);
  521.     for(loop=0;loop<32;loop++)
  522.     {
  523.         block(loop+2,18,loop+2);
  524.     }
  525.     for(loop=0;loop<36;loop++)
  526.     {
  527.         for(loop2=0;loop2<6;loop2++)
  528.         {
  529.             block(loop,loop2+19,loop*6+loop2+34);
  530.         }
  531.     }
  532. }
  533.  
  534. int what_color(int x,int y)
  535. {
  536.     if(x<288)
  537.     {
  538.         if(y<152 && y >143)
  539.         {
  540.             if(x>271)
  541.                 return(-1);
  542.             else
  543.                 return(x/8);
  544.         }
  545.         if(y>151)
  546.             return(x/8*6+y/8-19+34);
  547.  
  548.     }
  549.     return(-1);
  550. }
  551.  
  552. mapline(int mapx,int mapy,int x1, int y1, int x2, int y2, int linechar)
  553. {
  554.     int dx, dy, dxabs, dyabs, px, py, sdx, sdy, x, y;
  555.     int i;
  556.  
  557.     memset(screen,0xff,2000);
  558.     dx = x2 - x1;
  559.     dy = y2 - y1;
  560.     sdx = sign(dx);
  561.     sdy = sign(dy);
  562.     dxabs = abs(dx);
  563.     dyabs = abs(dy);
  564.     x = 0;
  565.     y = 0;
  566.     px = x1;
  567.     py = y1;
  568.     if (dxabs >= dyabs)
  569.     {
  570.         for (i=0; i<dxabs; i++)
  571.         {
  572.             y += dyabs;
  573.             if (y>=dxabs)
  574.             {
  575.                 y -= dxabs;
  576.                 py += sdy;
  577.             }
  578.             px += sdx;
  579.             mapptr[mapx+px+(mapy+py)*320]=linechar;
  580.             pch(px,py,linechar);
  581.         }
  582.     }
  583.     else
  584.     {
  585.         for (i=0; i<dyabs; i++)
  586.         {
  587.             x += dxabs;
  588.             if (x>=dyabs)
  589.             {
  590.                 x -= dyabs;
  591.                 px += sdx;
  592.             }
  593.             py += sdy;
  594.             mapptr[mapx+px+(mapy+py)*320]=linechar;
  595.             pch(px,py,linechar);
  596.         }
  597.     }
  598. }
  599.  
  600.  
  601. putsline(int x,char *string)
  602. {
  603.     int loop,loop2;
  604.  
  605.     for(loop=0;loop<strlen(string);loop++)
  606.         for(loop2=0;loop2<8;loop2++)
  607.             memcpy(scrptr+(loop+x)*8+(loop2)*320,csptr[*(string+loop)][loop2],8);
  608. }
  609.  
  610.  
  611.